home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / endo / re.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-12  |  7.8 KB  |  332 lines
  1. /*************************************************************************
  2.  *                                                                       *
  3.  *  Copyright (c) 1992, 1993 Ronald Joe Record                           *
  4.  *                                                                       *
  5.  *  All rights reserved. No part of this program or publication may be   *
  6.  *  reproduced, transmitted, transcribed, stored in a retrieval system,  *
  7.  *  or translated into any language or computer language, in any form or *
  8.  *  by any means, electronic, mechanical, magnetic, optical, chemical,   *
  9.  *  biological, or otherwise, without the prior written permission of:   *
  10.  *                                                                       *
  11.  *      Ronald Joe Record (408) 458-3718                                 *
  12.  *      212 Owen St., Santa Cruz, California 95062 USA                   *
  13.  *                                                                       *
  14.  *************************************************************************/
  15.  
  16. #include <values.h>
  17. #include "x.h"
  18. #ifdef USE_3D
  19. #include "globals.h"
  20. #endif
  21.  
  22. void 
  23. redisplay(event)
  24. XExposeEvent    *event;
  25. {
  26.     Pixmap pix;
  27.     extern int cornerbar;
  28.     extern double A, B, C, D;
  29.     extern void fillbar(), drawmap();
  30.  
  31.     if (event->window == canvas)
  32.         pix = pixmap;
  33.     else if (event->window == lyajec)
  34.         pix = pixmap;
  35.     else if (event->window == trajec)
  36.         pix = pixtra;
  37.     else if (event->window == crijec)
  38.         pix = pixcri;
  39.     else if (event->window == prejec)
  40.         pix = pixpre;
  41.     else if (event->window == info) {
  42.         Show_Info();
  43.         return;
  44.     }
  45.     else if (event->window == help) {
  46.         print_help();
  47.         return;
  48.     }
  49.     else if (event->window == hisbar) {
  50.         fillbar(hisbar, HISBARHGT, HISBARHGT, cornerbar);
  51.         return;
  52.     }
  53.     else if (event->window == colwin) {
  54.         XFillRectangle(dpy, colwin, Data_GC[0], 0, 0, ADJWIDTH, ADJHEIGHT);
  55.         drawmap(A, B, C, D);
  56.         return;
  57.     }
  58.     else {
  59.         perror("No defined window");
  60.         Cleanup();
  61.         exit(1);
  62.     }
  63.     /*
  64.      * Extract the exposed area from the event and copy
  65.      * from the saved pixmap to the window.
  66.      */
  67.     XCopyArea(dpy, pix, event->window, Data_GC[0], 
  68.        event->x, event->y, event->width, event->height, 
  69.        event->x, event->y);
  70.     if ((pix == pixtra) && (showbar == 2))
  71.         fillbar(trajec, traheight/2, traheight, cornerbar);
  72. }
  73.  
  74. void
  75. resize(w)
  76. Window      w;
  77. {
  78.     Window r;
  79.     static int n, x, y;
  80.     static XWindowAttributes attr;
  81.     static XWindowChanges values;
  82.     unsigned int new_w, new_h, bw, d;
  83.     extern int Qflag, p_inc, q_inc;
  84.     extern void Clear(), Redraw(); 
  85.     extern void FreeHist(), HistoMem(), FreeCrit(), CritiMem();
  86.     extern image_data_t rubber_data;
  87.  
  88.     XGetGeometry(dpy,w,&r,&x,&y,&new_w,&new_h,&bw,&d);
  89.     if ((w == canvas) || (w == lyajec) || (w == prejec)){
  90.         if ((new_w == width) && (new_h == height))
  91.             return;
  92.         freemem();
  93.         width = new_w; height = new_h;
  94.         XClearWindow(dpy,w);
  95.         if (pixmap)
  96.             XFreePixmap(dpy, pixmap);
  97.         pixmap = XCreatePixmap(dpy, DefaultRootWindow(dpy), 
  98.             width, height, DefaultDepth(dpy, screen));
  99.         if (pixpre)
  100.             XFreePixmap(dpy, pixpre);
  101.         pixpre = XCreatePixmap(dpy, DefaultRootWindow(dpy), 
  102.             width, height, DefaultDepth(dpy, screen));
  103.         x_inc = x_range / (double)width;
  104.         y_inc = y_range / (double)height;
  105.         point.x = 0;
  106.         point.y = 0;
  107.         maxexp = minexp = 0;
  108.         run = 1;
  109.         x = rubber_data.p_min = min_x;
  110.         y = rubber_data.q_min = min_y;
  111.         row = 1; numrows = 1;
  112.         if (Qflag == 4) {
  113.             x_inc = x_range / 4.0;
  114.             y_inc = y_range / 4.0;
  115.             p_inc = width / 4;
  116.             q_inc = height / 4;
  117.             numrows = row = 4;
  118.         }
  119.         rubber_data.p_max = max_x;
  120.         rubber_data.q_max = max_y;
  121.         for (n=0;n<MAXFRAMES;n++)
  122.             if ((n <= maxframe) && (n != frame))
  123.                   resized[n] = 1;
  124.         setupmem();
  125.         AllInitBuffer();
  126.         Clear(w); Clear(trajec); Clear(crijec); Clear(prejec);
  127.         values.width = width;
  128.         values.height = height;
  129.         if (w == canvas)
  130.             XConfigureWindow(dpy,lyajec,CWWidth|CWHeight,&values);
  131.         else
  132.             XConfigureWindow(dpy,canvas,CWWidth|CWHeight,&values);
  133.         XConfigureWindow(dpy,prejec,CWWidth|CWHeight,&values);
  134.         XGetWindowAttributes(dpy, info, &attr);
  135.         if (attr.map_state != IsUnmapped)
  136.             Show_Info();
  137.         Redraw();
  138.     }
  139.     else if (w == trajec) {
  140.         if ((new_w == trawidth) && (new_h == traheight))
  141.             return;
  142.         if (histogram)
  143.             FreeHist();
  144.         trawidth = new_w; traheight = new_h;
  145.         if (histogram)
  146.             HistoMem();
  147.         XClearWindow(dpy,trajec);
  148.         if (pixtra)
  149.             XFreePixmap(dpy, pixtra);
  150.         pixtra = XCreatePixmap(dpy, DefaultRootWindow(dpy), 
  151.             trawidth, traheight, DefaultDepth(dpy, screen));
  152. #ifdef USE_3D
  153.         if (thermometer)
  154.             screen_max.x = trawidth - THERMWIDTH;
  155.         else
  156.             screen_max.x = trawidth;
  157.         screen_max.y = traheight;
  158.         screen_center.x = screen_max.x >> 1;
  159.         screen_center.y = traheight >> 1;
  160. #endif
  161.         Clear(trajec);
  162.     }
  163.     else if (w == crijec) {
  164.         if ((new_w == criwidth) && (new_h == criheight))
  165.             return;
  166.         FreeCrit();
  167.         criwidth = new_w; criheight = new_h;
  168.         CritiMem();
  169.         XClearWindow(dpy,crijec);
  170.         if (pixcri)
  171.             XFreePixmap(dpy, pixcri);
  172.         pixcri = XCreatePixmap(dpy, DefaultRootWindow(dpy), 
  173.             criwidth, criheight, DefaultDepth(dpy, screen));
  174.         Clear(crijec);
  175.         if (critical) Remap_crit(crijec);
  176.     }
  177.     else {
  178.         perror("Attempt to resize unknown window");
  179.         Cleanup();
  180.         exit(-2);
  181.     }
  182. }
  183.  
  184. void
  185. redraw(indexarray, index, cont)
  186. int *indexarray;
  187. int index, cont;
  188. {
  189.     static int i;
  190.     static int x_sav, y_sav;
  191.  
  192.     x_sav = point.x;
  193.     y_sav = point.y;
  194.  
  195.     point.x = 0;
  196.     point.y = 0;
  197.  
  198.     save=0;
  199.     for (i=0;i<index;i++) {
  200.           BufferPoint(dpy,which,pixmap,Data_GC,&Points,
  201.                     indexarray[i],point.x,height-point.y-1);
  202.         if ((++point.x >= width) || 
  203.            (thermometer && (point.x >= width - THERMWIDTH))) {
  204.             point.x = 0;
  205.             point.y++;
  206.         }
  207.     }
  208.     save=1;
  209.     
  210.     if (cont) {
  211.         point.x = x_sav;
  212.         point.y = y_sav;
  213.     }
  214.     else {
  215.         x = point.x * x_inc + min_x;
  216.         y = point.y * y_inc + min_y;
  217.     }
  218.     AllFlushBuffer();
  219. }
  220.  
  221. void
  222. Redraw() 
  223. {
  224.     static int i, j, k;
  225.     extern int **histarray;
  226.     extern int found_arc, Qflag, q_inc, p_inc, minhist, maxhist;
  227.  
  228.     AllFlushBuffer();
  229.     point.x = 0;
  230.     point.y = 0;
  231.     minexp = maxexp = 0;
  232.     run = 1;
  233.     x = min_x;
  234.     y = min_y;
  235.     row = 1; numrows = 1;
  236.     if (Qflag == 4) {
  237.         x_inc = x_range / 4.0;
  238.         y_inc = y_range / 4.0;
  239.         p_inc = width / 4;
  240.         q_inc = height / 4;
  241.         numrows = row = 4;
  242.     }
  243.     found_arc = numcrits = numarcs = perind[frame] = 0;
  244.     resized[frame] = 0;
  245.     if (histogram) {
  246.         maxhist = 0;
  247.         minhist = MAXINT;
  248.         if (thermometer)
  249.             k = trawidth - THERMWIDTH;
  250.         else
  251.             k = trawidth;
  252.         for (i=0;i<traheight;i++)
  253.             for (j=0;j<k;j++)
  254.                 histarray[j][i] = 0;
  255.     }
  256.     Show_Info();
  257. }
  258.  
  259. remap_crit()
  260. {
  261.     static int i, color=MAXCOLOR;
  262.     static pair coords;
  263.     extern void Clear();
  264.  
  265.     Clear(crijec);
  266.     if (++color >= numcolors)
  267.         color = STARTCOLOR;
  268.     for (i=0;i<numcrits;i++) {
  269.         draw_critical(crijec, n_crit_pts[0][i],n_crit_pts[1][i],color);
  270.         coords=(*map)(n_crit_pts[0][i],n_crit_pts[1][i],params);
  271.         n_crit_pts[0][i] = coords.x;
  272.         n_crit_pts[1][i] = coords.y;
  273.     }
  274. }
  275.  
  276. Remap_crit(w)
  277. Window w;
  278. {
  279.     static int i, j, color;
  280.     static pair coords;
  281.  
  282.     for (j=0;j<numcrits;j++) {
  283.         coords.x = crit_pts[0][j];
  284.         coords.y = crit_pts[1][j];
  285.         n_crit_pts[0][j] = coords.x;
  286.         n_crit_pts[1][j] = coords.y;
  287.         color = 1;
  288.         for (i=0;i<settle+dwell;i++) {
  289.             draw_critical(w, coords.x,coords.y,color);
  290.             coords=(*map)(coords.x,coords.y,params);
  291.             if (++color >= STARTCOLOR)
  292.                 color = 1;
  293.         }
  294.     }
  295. }
  296.  
  297. remap_arcs()
  298. {
  299.     static int i;
  300.     static pair coords;
  301.     extern void Clear();
  302.  
  303.     Clear(crijec);
  304.     for (i=0;i<numarcs;i++) {
  305.         draw_critical(crijec, n_crit_arc[0][i],n_crit_arc[1][i],1);
  306.         coords=(*map)(n_crit_arc[0][i],n_crit_arc[1][i],params);
  307.         n_crit_arc[0][i] = coords.x;
  308.         n_crit_arc[1][i] = coords.y;
  309.     }
  310. }
  311.  
  312. Remap_arcs(w)
  313. Window w;
  314. {
  315.     static int i, j, color;
  316.     static pair coords;
  317.  
  318.     for (j=0;j<numarcs;j++) {
  319.         coords.x = crit_arc[0][j];
  320.         coords.y = crit_arc[1][j];
  321.         n_crit_arc[0][j] = coords.x;
  322.         n_crit_arc[1][j] = coords.y;
  323.         color = 1;
  324.         for (i=0;i<settle+dwell;i++) {
  325.             draw_critical(w, coords.x, coords.y, color);
  326.             coords=(*map)(coords.x, coords.y, params);
  327.             if (++color >= STARTCOLOR)
  328.                 color = 1;
  329.         }
  330.     }
  331. }
  332.